<?php

require_once("Lib/Parameters.php");

/**
 * Model che rappresenta un parametro nel DB.
 */
class ParametroGlobale extends StdModel
{

        private static $singleton = NULL;

        /**
         * Ritorna una istanza globale di questo model.
         * @return mixed La istanza globale.
         */
        public static function getInstance()
        {
                if(self::$singleton == NULL)
                        self::$singleton = new ParametroGlobale();
                return self::$singleton;
        }

        /*
         * Specifiche attributi del tipo del Model rappresentato da questa classe
         */
        public $attribTableName = Parameters::PARAMETERS_TABLE_NAME;
        public $attribLabel = "Nome";
        public $attribNames = array(STD_ID, "Nome", "Valore");
        public $attribExcludeFromAdd = array(STD_ID);
        public $attribExcludeFromEdit = array(STD_ID, "Nome");
        public $attribLongNames = array(STD_ID => "ID", "Nome" => "Nome", "Valore" => "Valore");
        public $attribIsImportant = array(STD_ID => 2, "Nome" => 1, "Valore" => 1);
        public $attribIsNumeric = array(STD_ID => true, "Nome" => false, "Valore" => false);
        public $attribIsForeignKey = array(STD_ID => false, "Nome" => false, "Valore" => false);

        /**
         * Restituisce l'HTML per creare un campo di un form adatto a contenere il
         * valore dell'attribbuto passato. Questo campo di testo sarà vuoto e dovrà
         * servire per la creazione di una nuova istanza in DB di questo model.
         * @param string $attribName Nome dell'attributo su cui creare il campo.
         * @return string Stringa contenente l'HTML dell'elemento creato.
         */
        public function getAddFormCodeFromAttribute($db,$attribName)
        {
                //i parametri non possono essere creati... i parametri e il loro numero
                //sono statici e ben definiti, mentre possono variare i loro valori.
                return "";
        }

        /**
         * Restituisce l'HTML per creare un campo di testo adatto a contenere il
         * valore dell'attribbuto passato. Questo campo di testo conterrà il valore
         * attualmente assunto da questo attributo in questa tupla.
         * @param DatabaseManager $db Database su cui effettuare una possibile
         * interrogazione.
         * @param string $attribName Nome dell'attributo di cui creare il codice.
         * @return string Il codice HTML dell'elemento form corrispondente.
         */
        public function getEditFormCodeFromAttribute($db, $attribName)
        {
                if($attribName == STD_ID)
                        return ModelUtils::getHiddenFormElement($attribName, $this->dataTupla[$attribName], false);
                if($attribName == "Nome")
                        return ModelUtils::getHiddenFormElement($attribName, $this->getDataLabel($db, $attribName));
                if($attribName == "Valore")
                {
                        $param = $this->dataTupla["Nome"];
                        if($param == Parameters::PARAMETER_ADMIN_PASS)
                                return ModelUtils::getTextFormElement ($attribName, $this->dataTupla[$attribName], true, NULL);//ModelUtils::getPasswordFormElement ($attribName, $this->dataTupla[$attribName], true, NULL);
                        elseif($param == Parameters::PARAMETER_PRINT_HEADING || $param == Parameters::PARAMETER_PRINT_LOGO || $param == Parameters::PARAMETER_PRINT_SIGNATURE)
                                return ModelUtils::getLongTextFormElement ($attribName, $this->dataTupla[$attribName], NULL, NULL, true);
                                //return ModelUtils::getRichTextAreaFormElement ($attribName, $this->dataTupla[$attribName], NULL, NULL, true);
                        elseif($param == Parameters::PARAMETER_IVA)
                                return ModelUtils::getTextFormElement ($attribName, $this->dataTupla[$attribName], true, 0);
                        else
                                return ModelUtils::getTextFormElement ($attribName, $this->dataTupla[$attribName], true, NULL);
                }
                return "";
        }

        /**
         * Costruttore che acquisisce l'array dei valori associativi.
         * @param type $data L'array associativo a cui inizializzare questa istanza.
         */
        public function __construct($data = NULL)
        {
                parent::__construct($data);
        }

        /**
         * Crea una nuova istanza della sottoclasse specializzante.
         * @param array $data I dati passati da cui recuperare i valori.
         * @return mixed Una nuova instanza della sottoclasse specializzante.
         */
        public function createNew($data)
        {
                return new ParametroGlobale($data);
        }
        
        /**
         * Aggiungi i valori di questa istanza al DB. L'ID di questa istanza
         * assumerà il valore della chiave primaria della tupla appena inserita nel
         * DB.
         * @param DatabaseManager $db Database su cui effettuare l'INSERT.
         * @return boolean Restituisce vero se l'INSERT è andato a buon fine, falso
         * altrimenti.
         */
        public function addToDB($db)
        {
                return false;
        }

        /**
         * Duplica i valori di una tupla, nel DB.
         * Eventuali sottoclassi potrebbero implementare questo metodo per duplicare
         * anche le associazioni NxN con un altra tabella.
         * @param DatabaseManager $db Database su cui effettuare l'INSERT.
         * @return mixed Restituisce l'istanza corrispondete alla nuova tupla se
         * l'INSERT è andato a buon fine, NULL altrimenti.
         */
        public function duplicateInDB($db)
        {
                return false;
        }

        /**
         * Rimuove dal DB la tupla rappresentata da questa instanza.
         * @param DatabaseManager $db Database su cui effettuare il REMOVE.
         * @return boolean Restituisce vero se il REMOVE è andato a buon fine, falso
         * altrimenti.
         */
        public function removeFromDB($db)
        {
                return false;
        }

        /**
         * Aggiorna I dati nel DB con quelli di questa istanza.
         * @param DatabaseManager $db Database su cui effettuare l'UPDATE.
         * @return boolean Restituisce vero se l'UPDATE è andato a buon fine, falso
         * altrimenti.
         */
        public function updateDB($db)
        {
                return Parameters::setParameterByID($db, $this->dataTupla[STD_ID], $this->dataTupla["Valore"]);
        }

        /**
         * Carica una nuova istanza con i valori di una specifica tupla del DB.
         * @param DatabaseManager $db Database da cui prelevare la tupla.
         * @param long $id Identificatore univoco che indica la tupla da prelevare.
         * @return mixed Ritorna la nuova istanza se il caricamento dei valori è
         * andato a buon fine, NULL altrimenti.
         */
        public function getFromDB($db, $id)
        {
                $parametersID = Parameters::getParametersIDList($db);
                if($parametersID == null)
                        return null;
                $key = null;
                foreach($parametersID as $k => $p)
                {
                        if($p == $id)
                        {
                                $key = $k;
                                break;
                        }
                }
                if($key === null)
                        return null;
                $paramValue = Parameters::getParameter($db, $key);
                $newdata = array();
                $newdata[STD_ID] = $id;
                $newdata["Nome"] = $key;
                $newdata["Valore"] = $paramValue;
                return $this->createNew($newdata);
        }

        /**
         * Carica dal DB una lista di istanze di questa sottoclasse caricate con i
         * valori delle tuple trovate secondo le specifiche passate.
         * @param DatabaseManager $db Database da cui prelevare le tuple.
         * @param int $limitMin Limite basso da cui iniziare a prelevare tuple, o
         * NULL per non usare i limiti.
         * @param int $limitMax Limite alto a cui fermarsi di prelevare tuple, o
         * NULL per non usare i limiti.
         * @param string $orderBy Ordinamento con cui prelevare le tuple, o "" per
         * non usare alcun ordinamento.
         * @return array L'array delle nuove istanze create a partire dai valori
         * trovati nel DB o NULL nel caso qualcosa sia andato storto.
         */
        public function getListFromDB($db, $limitMin, $limitMax, $orderBy, $cond = "")
        {
                $parameters = Parameters::getParametersList($db);
                if($parameters == null)
                        return null;
                $resArr = array();
                foreach($parameters as $k => $p)
                {
                        $newdata = array();
                        $newdata[STD_ID] = Parameters::getParameterID($db, $k);
                        $newdata["Nome"] = $k;
                        $newdata["Valore"] = $p;
                        $resArr[] = $this->createNew($newdata);
                }
                if($limitMin == NULL || $limitMax == NULL || ($limitMin == 0 && $limitMax >= count($resArr)) )
                        return $resArr;
                return array_slice($resArr,$limitMin, ($limitMax-$limitMin));
        }

        /**
         * Restituiscce il numero di tuple di questa tabella.
         * @param DatabaseManager $db Database da interrogare.
         * @return int Restituisce il numero di tuple presenti o FALSE in caso di
         * errore.
         */
        public function getRecordsNum($db)
        {
                return Parameters::getParametersCount();
        }

        /**
         * Metodo che restituisce una etichetta che rappresenta il valore di un
         * attributo: nella sua versione di default ritorna esattamente il valore
         * associato a quell'attributo, ma è possibile implementarlo nelle
         * sottoclassi per specificare opportuni comportamenti, come ad esempio di
         * non far stampare un numero che rappresenta una chiave esterna, ma invece
         * una etichetta della tupla ad essa associata.
         * @param DatabaseManager $db Database su cui poter effettuare una possibile
         * interrogazione.
         * @param string $attrib Attributo di cui stampare l'etichetta del valore.
         * @return string Il valore associato all'attributo o NULL se l'attributo
         * non è stato trovato.
         */
        public function getDataLabel($db, $attrib)
        {
                if($attrib == "Nome")
                        return Parameters::$PARAMETERS_LONG_NAMES[$this->dataTupla[$attrib]];
                elseif($attrib == "Valore")
                {
                        $pName = $this->dataTupla["Nome"];
                        if($pName == Parameters::PARAMETER_ADMIN_PASS)
                                return str_repeat("*",  strlen($this->dataTupla[$attrib]));
                        else
                                return ($this->dataTupla[$attrib]);
                        /*elseif($pName == Parameters::PARAMETER_PRINT_HEADING)
                                return ($this->dataTupla[$attrib]);
                        elseif($pName == Parameters::PARAMETER_PRINT_LOGO)
                                return ($this->dataTupla[$attrib]);
                        elseif($pName == Parameters::PARAMETER_PRINT_SIGNATURE)
                                return ($this->dataTupla[$attrib]);*/
                }
                else
                        return parent::getDataLabel ($db, $attrib);
        }

        /**
         * Restituisce vero se l'etichetta del valore dell'attributo passato viene
         * tagliata a 70 caratteri, o falso se essa viene stampata per intero.
         * @param string $attrib Attributo da controllare.
         * @return boolean Vero se l'etichetta del valore viene taglata, falso
         * altrimenti.
         */
        public function isDataLabelCut($attrib)
        {
                return false;
        }

}

?>